[windows-sources.git] / sdk / samples / all in on code / Visual Studio 2010 / CSSqlAzurePartitioning / WebRole1 / Scripts / jquery-1.4.1.js
| blob | b5c779c16b0e146251a3d1b0f803c51263d7920e |
1 /*!
2 * jQuery JavaScript Library v1.4.1
3 * http://jquery.com/
4 *
5 * Copyright 2010, John Resig
6 *
7 * Includes Sizzle.js
8 * http://sizzlejs.com/
9 * Copyright 2010, The Dojo Foundation
10 *
11 * Permission is hereby granted, free of charge, to any person obtaining
12 * a copy of this software and associated documentation files (the
13 * "Software"), to deal in the Software without restriction, including
14 * without limitation the rights to use, copy, modify, merge, publish,
15 * distribute, sublicense, and/or sell copies of the Software, and to
16 * permit persons to whom the Software is furnished to do so, subject to
17 * the following conditions:
18 *
19 * The above copyright notice and this permission notice shall be
20 * included in all copies or substantial portions of the Software.
21 *
22 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
23 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
24 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
25 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
26 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
27 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
28 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
29 * Date: Mon Jan 25 19:43:33 2010 -0500
30 */
33 // Define a local copy of jQuery
35 // The jQuery object is actually just the init constructor 'enhanced'
37 },
39 // Map over jQuery in case of overwrite
42 // Map over the $ in case of overwrite
45 // Use the correct document accordingly with window argument (sandbox)
48 // A central reference to the root jQuery(document)
49 rootjQuery,
51 // A simple way to check for HTML strings or ID strings
52 // (both of which we optimize for)
55 // Is it a simple selector
58 // Check if a string has a non-whitespace character in it
61 // Used for trimming whitespace
64 // Match a standalone tag
67 // Keep a UserAgent string for use with jQuery.browser
70 // For matching the engine and version of the browser
71 browserMatch,
73 // Has the ready events already been bound?
76 // The functions to execute on DOM ready
77 readyList = [],
79 // The ready event handler
80 DOMContentLoaded,
82 // Save a reference to some core methods
93 // Handle $(""), $(null), or $(undefined)
96 }
98 // Handle $(DOMElement)
103 }
105 // Handle HTML strings
107 // Are we dealing with HTML string or an ID?
110 // Verify a match, and that no context was specified for #id
113 // HANDLE: $(html) -> $(array)
117 // If a single string is passed in and it's a single tag
118 // just do a createElement and skip the rest
128 }
133 }
135 // HANDLE: $("#id")
140 // Handle the case where IE and Opera return items
141 // by name instead of ID
144 }
146 // Otherwise, we inject the element directly into the jQuery object
149 }
154 }
156 // HANDLE: $("TAG")
162 // HANDLE: $(expr, $(...))
166 // HANDLE: $(expr, context)
167 // (which is just equivalent to: $(context).find(expr)
170 }
172 // HANDLE: $(function)
173 // Shortcut for document ready
176 }
181 }
186 },
188 // Start with an empty selector
191 // The current version of jQuery being used
194 // The default length of a jQuery object is 0
197 // The number of elements contained in the matched element set
200 },
204 },
206 // Get the Nth element in the matched element set OR
207 // Get the whole matched element set as a clean array
211 // Return a 'clean' array
214 // Return just the object
216 },
218 // Take an array of elements and push it onto the stack
219 // (returning the new matched element set)
221 // Build a new jQuery matched element set
224 // Add the old object onto the stack (as a reference)
233 }
235 // Return the newly-formed element set
237 },
239 // Force the current matched set of elements to become
240 // the specified array of elements (destroying the stack in the process)
241 // You should use pushStack() in order to do this, but maintain the stack
243 // Resetting the length to 0, then using the native Array push
244 // is a super-fast way to populate an object with array-like properties
249 },
251 // Execute a callback for every element in the matched set.
252 // (You can seed the arguments with an array of args, but this is
253 // only used internally.)
256 },
259 // Attach the listeners
262 // If the DOM is already ready
264 // Execute the function immediately
267 // Otherwise, remember the function for later
269 // Add the function to the wait list
271 }
274 },
280 },
284 },
288 },
293 },
298 }));
299 },
303 },
305 // For internal use only.
306 // Behaves like an Array's method, not like a jQuery method.
309 splice: [].splice
310 };
312 // Give the init function the jQuery prototype for later instantiation
316 // copy reference to target object
317 var target = arguments[0] || {}, i = 1, length = arguments.length, deep = false, options, name, src, copy;
319 // Handle a deep copy situation
323 // skip the boolean and the target
325 }
327 // Handle case when target is a string or something (possible in deep copy)
329 target = {};
330 }
332 // extend jQuery itself if only one argument is passed
336 }
339 // Only deal with non-null/undefined values
341 // Extend the base object
346 // Prevent never-ending loop
349 }
351 // Recurse if we're merging object literal values or arrays
356 // Never move original objects, clone them
359 // Don't bring in undefined values
362 }
363 }
364 }
365 }
367 // Return the modified object
369 };
377 }
380 },
382 // Is the DOM ready to be used? Set to true once it occurs.
385 // Handle when the DOM is ready
387 // Make sure that the DOM is not already loaded
389 // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
392 }
394 // Remember that the DOM is ready
397 // If there are functions bound, to execute
399 // Execute all of them
403 }
405 // Reset the list of functions
407 }
409 // Trigger any bound ready events
412 }
413 }
414 },
419 }
423 // Catch cases where $(document).ready() is called after the
424 // browser event has already occurred.
427 }
429 // Mozilla, Opera and webkit nightlies currently support this event
431 // Use the handy event callback
434 // A fallback to window.onload, that will always work
437 // If IE event model is used
439 // ensure firing before onload,
440 // maybe late but safe also for iframes
443 // A fallback to window.onload, that will always work
446 // If IE and not a frame
447 // continually check to see if the document is ready
456 }
457 }
458 },
460 // See test/unit/core.js for details concerning isFunction.
461 // Since version 1.3, DOM methods and functions like alert
462 // aren't supported. They return false on IE (#2968).
465 },
469 },
472 // Must be an Object.
473 // Because of IE, we also have to check the presence of the constructor property.
474 // Make sure that DOM nodes and window objects don't pass through, as well
477 }
479 // Not own constructor property must be Object
484 }
486 // Own properties are enumerated firstly, so to speed up,
487 // if last one is own, then all properties are own.
493 },
498 }
500 },
504 },
509 }
511 // Make sure the incoming data is actual JSON
512 // Logic borrowed from http://json.org/json2.js
517 // Try to use the native JSON parser first
524 }
525 },
529 // Evalulates a script in a global context
532 // Inspired by code by Andrea Giammarchi
533 // http://webreflection.blogspot.com/2007/08/global-scope-evaluation-and-dom.html
543 }
545 // Use insertBefore instead of appendChild to circumvent an IE6 bug.
546 // This arises when a base node is used (#2709).
549 }
550 },
554 },
556 // args is for internal usage only
567 }
568 }
573 }
574 }
575 }
577 // A special, fast, case for the most common use of each
583 }
584 }
588 }
589 }
592 },
596 },
598 // results is for internal usage only
603 // The window, strings (and functions) also have 'length'
604 // The extra typeof function check is to prevent crashes
605 // in Safari 2 (See: #3039)
606 if ( array.length == null || typeof array === "string" || jQuery.isFunction(array) || (typeof array !== "function" && array.setInterval) ) {
610 }
611 }
614 },
619 }
624 }
625 }
628 },
636 }
640 }
641 }
646 },
651 // Go through the array, only saving the items
652 // that pass the validator function
656 }
657 }
660 },
662 // arg is for internal usage only
666 // Go through the array, translating each of the items to their
667 // new value (or values).
673 }
674 }
677 },
679 // A global GUID counter for objects
692 }
693 }
698 };
699 }
701 // Set the guid of unique handler to the same of original handler, so it can be removed
704 }
706 // So proxy can be declared as an argument
708 },
710 // Use of jQuery.browser is frowned upon.
711 // More details: http://docs.jquery.com/Utilities/jQuery.browser
719 [];
722 },
724 browser: {}
725 });
731 }
733 // Deprecated, use jQuery.browser.webkit instead
736 }
741 };
742 }
744 // All jQuery objects should point back to these
747 // Cleanup functions for the document ready method
752 };
756 // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
760 }
761 };
762 }
764 // The DOM ready check for Internet Explorer
768 }
771 // If IE is used, use the trick by Diego Perini
772 // http://javascript.nwbox.com/IEContentLoaded/
777 }
779 // and execute any waiting functions
781 }
789 });
792 }
796 }
797 }
799 // Mutifunctional method to get and set values to a collection
800 // The value/s can be optionally by executed if its a function
804 // Setting many attributes
808 }
810 }
812 // Setting one attribute
814 // Optionally, function values get executed if exec is true
819 }
822 }
824 // Getting an attribute
826 }
830 }
841 div.innerHTML = " <link/><table></table><a href='/a' style='color:red;float:left;opacity:.55;'>a</a><input type='checkbox'/>";
846 // Can't get basic test support
849 }
852 // IE strips leading whitespace when .innerHTML is used
855 // Make sure that tbody elements aren't automatically inserted
856 // IE will insert them into empty tables
859 // Make sure that link elements get serialized correctly by innerHTML
860 // This requires a wrapper element in IE
863 // Get the style information from getAttribute
864 // (IE uses .cssText insted)
867 // Make sure that URLs aren't manipulated
868 // (IE normalizes it by default)
871 // Make sure that element opacity exists
872 // (IE uses filter instead)
873 // Use a regex to work around a WebKit issue. See #5145
876 // Verify style float existence
877 // (IE uses styleFloat instead of cssFloat)
880 // Make sure that if no value is specified for a checkbox
881 // that it defaults to "on".
882 // (WebKit defaults to "" instead)
885 // Make sure that a selected-by-default option has a working selected property.
886 // (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
887 optSelected: document.createElement("select").appendChild( document.createElement("option") ).selected,
889 // Will be defined later
894 };
903 // Make sure that the execution of code works by injecting a script
904 // tag with appendChild/createTextNode
905 // (IE doesn't support this, fails, and uses .text instead)
909 }
915 // Cloning a node shouldn't copy over any
916 // bound event handlers (IE does this)
919 });
921 }
929 // WebKit doesn't clone checked state correctly in fragments
932 // Figure out if the W3C box model works as expected
933 // document.body must exist before we can do this
942 });
944 // Technique from Juriy Zaytsev
945 // http://thinkweb2.com/projects/prototype/detecting-event-support-without-browser-sniffing/
954 }
958 };
963 // release memory in IE
965 })();
978 };
983 cache: {},
987 // The following elements throw uncatchable exceptions if you
988 // attempt to add expando properties to them.
989 noData: {
993 },
998 }
1001 windowData :
1002 elem;
1006 // Handle the case where there's no name immediately
1009 }
1011 // Compute a unique ID for the element
1014 }
1016 // Avoid generating a new cache unless none exists and we
1017 // want to manipulate it.
1027 }
1029 // Prevent overriding the named cache with undefined values
1033 }
1036 },
1041 }
1044 windowData :
1045 elem;
1049 // If we want to remove a specific section of the element's data
1052 // Remove the section of cache data
1055 // If we've removed all the data, remove the element's cache
1058 }
1059 }
1061 // Otherwise, we want to remove all of the element's data
1063 // Clean up the element expando
1067 // IE has trouble directly removing the expando
1068 // but it's ok with using removeAttribute
1071 }
1072 }
1074 // Completely remove the data cache
1076 }
1077 }
1078 });
1088 });
1089 }
1099 }
1102 data;
1106 });
1107 }
1108 },
1113 });
1114 }
1115 });
1120 }
1125 // Speed up dequeue by getting out quickly if this is just a lookup
1128 }
1135 }
1138 },
1145 // If the fx queue is dequeued, always remove the progress sentinel
1148 }
1151 // Add a progress sentinel to prevent the fx queue from being
1152 // automatically dequeued
1155 }
1159 });
1160 }
1161 }
1162 });
1169 }
1173 }
1179 }
1180 });
1181 },
1185 });
1186 },
1188 // Based off of the plugin by Clint Helfers, with permission.
1189 // http://blindsignals.com/index.php/2009/07/jquery-delay/
1199 });
1200 },
1204 }
1205 });
1218 },
1225 }
1226 });
1227 },
1234 });
1235 }
1252 }
1253 }
1254 }
1255 }
1256 }
1257 }
1260 },
1267 });
1268 }
1281 }
1286 }
1287 }
1288 }
1289 }
1292 },
1301 });
1302 }
1306 // toggle individual class names
1312 // check each className given, space seperated list
1315 }
1319 // store className if set
1321 }
1323 // toggle whole className
1324 this.className = this.className || value === false ? "" : jQuery.data( this, "__className__" ) || "";
1325 }
1326 });
1327 },
1334 }
1335 }
1338 },
1347 }
1349 // We need to handle select boxes special
1352 values = [],
1356 // Nothing was selected
1359 }
1361 // Loop through all the selected options
1366 // Get the specifc value for the option
1369 // We don't need an array for one selects
1372 }
1374 // Multi-Selects return an array
1376 }
1377 }
1380 }
1382 // Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified
1385 }
1388 // Everything else, we just grab the value
1391 }
1394 }
1403 }
1407 }
1409 // Typecast each time if the value is a Function and the appended
1410 // value is therefore different each time.
1413 }
1423 });
1427 }
1431 }
1432 });
1433 }
1434 });
1437 attrFn: {
1446 },
1449 // don't set attributes on text and comment nodes
1452 }
1456 }
1459 // Whether we are setting (or getting)
1462 // Try to normalize/fix the name
1465 // Only do all the following if this is a node (faster for style)
1467 // These attributes require special treatment
1470 // Safari mis-reports the default selected property of an option
1471 // Accessing the parent's selectedIndex property fixes it
1477 // Make sure that it also works with optgroups, see #5701
1480 }
1481 }
1482 }
1484 // If applicable, access the attribute via the DOM 0 way
1487 // We can't allow the type property to be changed (since it causes problems in IE)
1490 }
1493 }
1495 // browsers index elements by id/name on forms, give priority to attributes.
1498 }
1500 // elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
1501 // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
1510 }
1513 }
1518 }
1521 }
1524 // convert the value to a string (all browsers do this but IE) see #1070
1526 }
1529 // Some attributes require a special call on IE
1533 // Non-existent attributes return null, we normalize to undefined
1535 }
1537 // elem is actually elem.style ... set the style
1538 // Using attr for specific style information is now deprecated. Use style insead.
1540 }
1541 });
1545 });
1546 };
1548 /*
1549 * A number of helper functions used for managing events.
1550 * Many of the ideas behind this code originated from
1551 * Dean Edwards' addEvent library.
1552 */
1555 // Bind an event to an element
1556 // Original by Dean Edwards
1560 }
1562 // For whatever reason, IE has trouble passing the window object
1563 // around, causing it to be cloned in the process
1566 }
1568 // Make sure that the function being executed has a unique ID
1571 }
1573 // if data is passed, bind to handler
1575 // Create temporary function pointer to original handler
1578 // Create unique handler function, wrapped around original handler
1581 // Store data in unique handler
1583 }
1585 // Init the element's event structure
1591 // Handle the second event of a trigger and when
1592 // an event is called after a page has unloaded
1596 };
1599 }
1601 // If no handle is found then we must be trying to bind to one of the
1602 // banned noData elements
1605 }
1607 // Add elem as a property of the handle function
1608 // This is to prevent a memory leak with non-native
1609 // event in IE.
1612 // Handle multiple events separated by a space
1613 // jQuery(...).bind("mouseover mouseout", fn);
1619 // Namespaced event handlers
1628 }
1629 }
1633 // Get the current list of functions bound to this event
1637 // Init the event handler queue
1641 // Check for a special event handler
1642 // Only use addEventListener/attachEvent if the special
1643 // events handler returns false
1645 // Bind the global event handler to the element
1650 }
1651 }
1652 }
1661 }
1662 }
1664 // Add the function to the element's handler list
1667 // Keep track of which events have been used, for global triggering
1669 }
1671 // Nullify elem to prevent memory leaks in IE
1673 },
1675 global: {},
1677 // Detach an event or set of events from an element
1679 // don't do events on text and comment nodes
1682 }
1687 // Unbind all events for the element
1691 }
1693 // types is actually an event object here
1697 }
1699 // Handle multiple events separated by a space
1700 // jQuery(...).unbind("mouseover mouseout", fn);
1704 // Namespaced event handlers
1713 // remove the given handler for the given type
1718 // remove all handlers for the given type
1721 // Handle the removal of namespaced events
1724 }
1725 }
1726 }
1730 }
1732 // remove generic event handler if no more handlers exist
1735 }
1742 }
1743 }
1746 }
1747 }
1748 }
1749 }
1751 // Remove the expando if it's no longer used
1754 }
1759 }
1762 }
1763 }
1764 },
1766 // bubbling is internal
1768 // Event object or event type
1774 // jQuery.Event object
1776 // Object literal
1778 // Just the event type (string)
1784 }
1786 // Handle a global trigger
1788 // Don't bubble custom events when global (to avoid too much overhead)
1791 // Only trigger if we've ever bound an event for it
1796 }
1797 });
1798 }
1799 }
1801 // Handle triggering a single element
1803 // don't do events on text and comment nodes
1806 }
1808 // Clean up in case it is reused
1812 // Clone the incoming data, if any
1815 }
1819 // Trigger the event, it is assumed that "handle" is a function
1823 }
1827 // Trigger an inline bound script
1832 }
1833 }
1835 // prevent IE from throwing an error for some elements with some event types, see #3533
1845 if ( !isClick && !(target && target.nodeName && jQuery.noData[target.nodeName.toLowerCase()]) ) {
1848 // Make sure that we don't accidentally re-trigger the onFOO events
1853 }
1857 }
1859 // prevent IE from throwing an error for some elements with some event types, see #3533
1864 }
1867 }
1868 }
1869 },
1872 // returned undefined or false
1878 // Namespaced event handlers
1882 // Cache this now, all = true means, any handler
1885 var namespace = new RegExp("(^|\\.)" + namespaces.slice(0).sort().join("\\.(?:.*\\.)?") + "(\\.|$)");
1892 // Filter the functions by class
1894 // Pass in a reference to the handler function itself
1895 // So that we can later remove it
1906 }
1907 }
1911 }
1913 }
1914 }
1917 },
1919 props: "altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode layerX layerY metaKey newValue offsetX offsetY originalTarget pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target toElement view wheelDelta which".split(" "),
1924 }
1926 // store a copy of the original event object
1927 // and "clone" to set read-only properties
1934 }
1936 // Fix target property, if necessary
1938 event.target = event.srcElement || document; // Fixes #1925 where srcElement might not be defined either
1939 }
1941 // check if target is a textnode (safari)
1944 }
1946 // Add relatedTarget, if necessary
1948 event.relatedTarget = event.fromElement === event.target ? event.toElement : event.fromElement;
1949 }
1951 // Calculate pageX/Y if missing and clientX/Y available
1954 event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);
1955 event.pageY = event.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc && doc.clientTop || body && body.clientTop || 0);
1956 }
1958 // Add which for key events
1959 if ( !event.which && ((event.charCode || event.charCode === 0) ? event.charCode : event.keyCode) ) {
1961 }
1963 // Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
1966 }
1968 // Add which for click: 1 === left; 2 === middle; 3 === right
1969 // Note: button is not normalized, so don't use it
1971 event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
1972 }
1975 },
1977 // Deprecated, use jQuery.guid instead
1980 // Deprecated, use jQuery.proxy instead
1983 special: {
1984 ready: {
1985 // Make sure the ready event is setup
1988 },
1990 live: {
1999 },
2007 remove++;
2008 }
2009 });
2013 }
2014 }
2015 },
2016 special: {}
2017 },
2018 beforeunload: {
2020 // We only want to do this special case on windows
2023 }
2026 },
2030 }
2031 }
2032 }
2033 }
2034 };
2037 // Allow instantiation without the 'new' keyword
2040 }
2042 // Event object
2046 // Event type
2049 }
2051 // timeStamp is buggy for some events on Firefox(#3843)
2052 // So we won't rely on the native value
2055 // Mark it as fixed
2057 };
2061 }
2064 }
2066 // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
2067 // http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
2075 }
2077 // if preventDefault exists run it on the original event
2080 }
2081 // otherwise set the returnValue property of the original event to false (IE)
2083 },
2090 }
2091 // if stopPropagation exists run it on the original event
2094 }
2095 // otherwise set the cancelBubble property of the original event to true (IE)
2097 },
2101 },
2104 isImmediatePropagationStopped: returnFalse
2105 };
2107 // Checks if an event happened on an element within another element
2108 // Used in jQuery.event.special.mouseenter and mouseleave handlers
2110 // Check if mouse(over|out) are still within the same parent element
2113 // Traverse up the tree
2115 // Firefox sometimes assigns relatedTarget a XUL element
2116 // which we cannot access the parentNode property of
2120 // assuming we've left the element since we most likely mousedover a xul element
2123 }
2124 }
2127 // set the correct event type
2130 // handle event if we actually just moused on to a non sub-element
2132 }
2134 },
2136 // In case of event delegation, we only need to rename the event.type,
2137 // liveHandler will take care of the rest.
2141 };
2143 // Create mouseenter and mouseleave events
2151 },
2154 }
2155 };
2156 });
2158 // submit delegation
2169 }
2170 });
2175 if ( (type === "text" || type === "password") && jQuery( elem ).closest("form").length && e.keyCode === 13 ) {
2177 }
2178 });
2182 }
2183 },
2188 }
2189 };
2191 }
2193 // change delegation, happens here so we have bind.
2213 }
2216 }
2223 }
2228 // the current data will be also retrieved by beforeactivate
2231 }
2235 }
2240 }
2241 }
2244 filters: {
2252 }
2253 },
2255 // Change has to be called before submit
2256 // Keydown will be called before keypress, which is used in submit-event delegation
2264 }
2265 },
2267 // Beforeactivate happens also before the previous element is blurred
2268 // with this event you can't trigger a change event, but you can store
2269 // information/focus[in] is not needed anymore
2275 }
2276 }
2277 },
2281 }
2284 },
2287 jQuery.event.remove( this, type + ".specialChange" + (fn ? "."+fn.guid : ""), changeFilters[type] );
2288 }
2291 }
2292 };
2296 }
2301 }
2303 // Create "bubbling" focus and blur events
2309 },
2312 }
2313 };
2319 }
2320 });
2321 }
2325 // Handle object literals
2329 }
2331 }
2336 }
2347 });
2348 };
2349 });
2353 // Handle object literals
2357 }
2359 }
2363 });
2364 },
2368 });
2369 },
2378 }
2379 },
2382 // Save reference to arguments for access in closure
2385 // link all the functions, so any of them can unbind this click handler
2388 }
2391 // Figure out which function to execute
2395 // Make sure that clicks stop
2398 // and execute the function
2400 }));
2401 },
2405 }
2406 });
2415 }
2423 type;
2426 // bind live handler
2432 // unbind live handler
2433 jQuery( this.context ).unbind( liveConvert( type, this.selector ), fn ? { guid: fn.guid + this.selector + type } : null );
2434 }
2435 }
2438 }
2439 });
2446 // Make sure we avoid non-left-click bubbling in Firefox (#3861)
2449 }
2460 }
2463 }
2464 }
2475 // Those two events require additional checking
2478 }
2482 }
2483 }
2484 }
2485 }
2494 }
2495 }
2498 }
2502 }
2508 // Handle event binding
2511 };
2515 }
2516 });
2518 // Prevent memory leaks in IE
2519 // Window isn't included so as not to unbind existing unload events
2520 // More info:
2521 // - http://isaacschlueter.com/2006/10/msie-memory-leaks/
2526 // Try/Catch is to handle iframes being unloaded, see #4280
2530 }
2531 }
2532 });
2533 }
2534 /*!
2535 * Sizzle CSS Selector Engine - v1.0
2536 * Copyright 2009, The Dojo Foundation
2537 * More information: http://sizzlejs.com/
2538 *
2539 * Permission is hereby granted, free of charge, to any person obtaining
2540 * a copy of this software and associated documentation files (the
2541 * "Software"), to deal in the Software without restriction, including
2542 * without limitation the rights to use, copy, modify, merge, publish,
2543 * distribute, sublicense, and/or sell copies of the Software, and to
2544 * permit persons to whom the Software is furnished to do so, subject to
2545 * the following conditions:
2546 *
2547 * The above copyright notice and this permission notice shall be
2548 * included in all copies or substantial portions of the Software.
2549 *
2550 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
2551 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
2552 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
2553 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
2554 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
2555 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
2556 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
2557 */
2560 var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^[\]]*\]|['"][^'"]*['"]|[^[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g,
2566 // Here we check if the JavaScript engine is using some sort of
2567 // optimization where it does not always call our comparision
2568 // function. If that is the case, discard the hasDuplicate value.
2569 // Thus far that includes Google Chrome.
2573 });
2581 }
2585 }
2590 // Reset the position of the chunker regexp (start from head)
2599 }
2600 }
2615 }
2618 }
2619 }
2621 // Take a shortcut and set the context if the root selector is an ID
2622 // (but not if it'll be faster if the inner selector is an ID)
2627 }
2632 Sizzle.find( parts.pop(), parts.length === 1 && (parts[0] === "~" || parts[0] === "+") && context.parentNode ? context.parentNode : context, contextXML );
2639 }
2648 }
2652 }
2655 }
2658 }
2659 }
2663 }
2667 }
2674 if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && contains(context, checkSet[i])) ) {
2676 }
2677 }
2682 }
2683 }
2684 }
2687 }
2692 }
2695 };
2706 }
2707 }
2708 }
2709 }
2712 };
2716 };
2723 }
2738 }
2739 }
2740 }
2741 }
2745 }
2748 };
2764 }
2767 result = [];
2768 }
2777 }
2778 }
2791 }
2795 }
2796 }
2797 }
2798 }
2803 }
2809 }
2812 }
2813 }
2814 }
2816 // Improper expression
2822 }
2823 }
2826 }
2829 };
2833 };
2837 match: {
2846 },
2847 leftMatch: {},
2848 attrMap: {
2851 },
2852 attrHandle: {
2855 }
2856 },
2857 relative: {
2865 }
2874 }
2875 }
2879 }
2880 },
2892 }
2893 }
2901 }
2902 }
2906 }
2907 }
2908 },
2915 }
2918 },
2925 }
2928 }
2929 },
2930 find: {
2935 }
2936 },
2944 }
2945 }
2948 }
2949 },
2952 }
2953 },
2954 preFilter: {
2960 }
2964 if ( not ^ (elem.className && (" " + elem.className + " ").replace(/[\t\n]/g, " ").indexOf(match) >= 0) ) {
2967 }
2970 }
2971 }
2972 }
2975 },
2978 },
2981 },
2984 // parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
2989 // calculate the numbers (first)n+(last) including if they are negative
2992 }
2994 // TODO: Move to normal caching system
2998 },
3004 }
3008 }
3011 },
3014 // If we're dealing with a complex expression, or a simple one
3021 }
3023 }
3026 }
3029 },
3033 }
3034 },
3035 filters: {
3038 },
3041 },
3044 },
3046 // Accessing this property makes selected-by-default
3047 // options in Safari work properly
3050 },
3053 },
3056 },
3059 },
3062 },
3065 },
3068 },
3071 },
3074 },
3077 },
3080 },
3083 },
3086 },
3089 },
3092 }
3093 },
3094 setFilters: {
3097 },
3100 },
3103 },
3106 },
3109 },
3112 },
3115 },
3118 }
3119 },
3120 filter: {
3134 }
3135 }
3140 }
3141 },
3150 }
3151 }
3154 }
3160 }
3161 }
3168 }
3178 }
3179 }
3181 }
3188 }
3189 }
3190 },
3193 },
3196 },
3200 },
3231 },
3237 }
3238 }
3239 }
3240 };
3245 Expr.match[ type ] = new RegExp( Expr.match[ type ].source + /(?![^\[]*\])(?![^\(]*\))/.source );
3246 Expr.leftMatch[ type ] = new RegExp( /(^(?:.|\r|\n)*?)/.source + Expr.match[ type ].source.replace(/\\(\d+)/g, function(all, num){
3248 }));
3249 }
3257 }
3260 };
3262 // Perform a simple check to determine if the browser is capable of
3263 // converting a NodeList to an array using builtin methods.
3267 // Provide a fallback method if it does not work
3278 }
3282 }
3283 }
3284 }
3287 };
3288 }
3297 }
3299 }
3304 }
3306 };
3312 }
3314 }
3319 }
3321 };
3327 }
3329 }
3339 }
3341 };
3342 }
3344 // Utility function for retreiving the text value of an array of DOM nodes
3351 // Get the text from text nodes and CDATA nodes
3355 // Traverse everything else, except comment nodes
3358 }
3359 }
3362 }
3364 // Check to see if the browser returns elements by name when
3365 // querying by getElementById (and provide a workaround)
3367 // We're going to inject a fake input element with a specified name
3372 // Inject it into the root element, check its status, and remove it quickly
3376 // The workaround has to do additional checks after a getElementById
3377 // Which slows things down for other browsers (hence the branching)
3382 return m ? m.id === match[1] || typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ? [m] : undefined : [];
3383 }
3384 };
3389 };
3390 }
3394 })();
3397 // Check to see if the browser returns only elements
3398 // when doing getElementsByTagName("*")
3400 // Create a fake element
3404 // Make sure no comments are found
3409 // Filter out possible comments
3416 }
3417 }
3420 }
3423 };
3424 }
3426 // Check to see if an attribute returns normalized href attributes
3432 };
3433 }
3436 })();
3443 // Safari can't handle uppercase or unicode characters when
3444 // in quirks mode.
3447 }
3452 // Only use querySelectorAll on non-XML documents
3453 // (ID selectors don't work in non-HTML documents)
3458 }
3461 };
3465 }
3468 })();
3469 }
3476 // Opera can't find a second classname (in 9.6)
3477 // Also, make sure that getElementsByClassName actually exists
3480 }
3482 // Safari caches class attributes, doesn't catch changes (in 3.2)
3487 }
3493 }
3494 };
3497 })();
3510 }
3515 }
3520 }
3523 }
3526 }
3527 }
3528 }
3541 }
3547 }
3552 }
3557 }
3558 }
3561 }
3564 }
3565 }
3566 }
3572 };
3575 // documentElement is verified for cases where it doesn't yet exist
3576 // (such as loading iframes in IE - #4833)
3579 };
3585 // Position selectors must be done after the filter
3586 // And so must :not(positional) so we move all PSEUDOs to the end
3590 }
3596 }
3599 };
3601 // EXPOSE
3614 })();
3617 // Note: This RegExp should be improved, or likely pulled from Sizzle
3618 rmultiselector = /,/,
3621 // Implement the identical functionality for filter and not
3626 });
3631 });
3636 });
3642 }
3643 }
3647 });
3648 };
3659 // Make sure that the results are unique
3665 }
3666 }
3667 }
3668 }
3669 }
3672 },
3680 }
3681 }
3682 });
3683 },
3687 },
3691 },
3695 },
3708 selector;
3709 }
3710 }
3719 }
3720 }
3722 }
3723 }
3726 }
3735 }
3737 }
3739 });
3740 },
3742 // Determine the position of an element within
3743 // the matched set of elements
3747 // If it receives a string, the selector is used
3748 // If it receives nothing, the siblings are used
3750 }
3751 // Locate the position of the desired element
3753 // If it receives a jQuery object, the first element is used
3755 },
3764 all :
3766 },
3770 }
3771 });
3773 // A painfully simple check to see if an element is disconnected
3774 // from a document (should be improved, where feasible).
3777 }
3783 },
3786 },
3789 },
3792 },
3795 },
3798 },
3801 },
3804 },
3807 },
3810 },
3813 },
3818 }
3825 }
3829 }
3835 }
3838 };
3839 });
3845 }
3848 },
3852 while ( cur && cur.nodeType !== 9 && (until === undefined || cur.nodeType !== 1 || !jQuery( cur ).is( until )) ) {
3855 }
3857 }
3859 },
3868 }
3869 }
3872 },
3880 }
3881 }
3884 }
3885 });
3896 all :
3898 },
3899 wrapMap = {
3908 };
3914 // IE can't serialize <link> and <script> tags normally
3917 }
3925 });
3926 }
3929 return this.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) );
3930 }
3933 },
3939 });
3940 }
3943 // The elements to wrap the target around
3948 }
3955 }
3959 }
3962 },
3968 });
3969 }
3979 }
3980 });
3981 },
3986 });
3987 },
3993 }
3995 },
4001 }
4002 });
4003 },
4009 }
4010 });
4011 },
4017 });
4022 }
4023 },
4029 });
4034 }
4035 },
4038 // Do the clone
4041 // IE copies events bound via attachEvent when
4042 // using cloneNode. Calling detachEvent on the
4043 // clone will also remove the events from the orignal
4044 // In order to get around this, we use innerHTML.
4045 // Unfortunately, this means some modifications to
4046 // attributes in IE that are actually only stored
4047 // as properties will not be copied (such as the
4048 // the name attribute on an input).
4054 }
4060 }
4061 });
4063 // Copy the events from the original to the clone
4067 }
4069 // Return the cloned set
4071 },
4079 // See if we can take a shortcut and just use innerHTML
4088 // Remove element nodes and prevent memory leaks
4092 }
4093 }
4095 // If using innerHTML throws an exception, use the fallback method
4098 }
4105 });
4106 });
4110 }
4113 },
4117 // Make sure that the elements are removed from the DOM before they are inserted
4118 // this can help fix replacing a parent with child elements
4126 });
4127 }
4138 }
4139 });
4141 return this.pushStack( jQuery(jQuery.isFunction(value) ? value() : value), "replaceWith", value );
4142 }
4143 },
4147 },
4152 // We can't cloneNode fragments that contain checked, in WebKit
4153 if ( !jQuery.support.checkClone && arguments.length === 3 && typeof value === "string" && rchecked.test( value ) ) {
4156 });
4157 }
4164 });
4165 }
4168 // If we're in a fragment, just use that instead of building a new one
4173 }
4182 table ?
4187 results.fragment
4188 );
4189 }
4190 }
4194 }
4195 }
4203 elem;
4204 }
4205 }
4206 });
4214 }
4216 var oldData = jQuery.data( orig[i++] ), curData = jQuery.data( this, oldData ), events = oldData && oldData.events;
4225 }
4226 }
4227 }
4228 });
4229 }
4234 // webkit does not clone 'checked' attribute of radio inputs on cloneNode, so don't cache if string has a checked
4235 if ( args.length === 1 && typeof args[0] === "string" && args[0].length < 512 && args[0].indexOf("<option") < 0 && (jQuery.support.checkClone || !rchecked.test( args[0] )) ) {
4241 }
4242 }
4243 }
4249 }
4253 }
4256 }
4274 }
4276 };
4277 });
4280 // keepData is for internal use only--do not document
4286 }
4290 }
4291 }
4292 },
4295 // Remove element nodes and prevent memory leaks
4298 }
4300 // Remove any remaining nodes
4303 }
4304 }
4308 };
4309 });
4315 // !context.createElement fails in IE with an error but returns typeof 'object'
4318 }
4325 }
4329 }
4331 // Convert html string into DOM nodes
4336 // Fix "XHTML"-style tags in all browsers
4339 // Trim whitespace, otherwise indexOf won't work as expected
4345 // Go to html and back, then peel off extra wrappers
4348 // Move to the right depth
4351 }
4353 // Remove IE's autoinserted <tbody> from table fragments
4356 // String was a <table>, *may* have spurious <tbody>
4361 // String was a bare <thead> or <tfoot>
4364 [];
4369 }
4370 }
4372 }
4374 // IE completely kills leading whitespace when innerHTML is used
4376 div.insertBefore( context.createTextNode( rleadingWhitespace.exec(elem)[0] ), div.firstChild );
4377 }
4380 }
4386 }
4388 });
4392 if ( scripts && jQuery.nodeName( ret[i], "script" ) && (!ret[i].type || ret[i].type.toLowerCase() === "text/javascript") ) {
4396 ret.splice.apply( ret, [i + 1, 0].concat(jQuery.makeArray(ret[i].getElementsByTagName("script"))) );
4397 }
4399 }
4400 }
4401 }
4404 },
4410 }
4411 }
4412 });
4413 // exclude the following css properties to add px
4427 // cache check for defaultView.getComputedStyle
4429 // normalize float css property
4433 };
4439 }
4443 }
4446 });
4447 };
4451 // don't set styles on text and comment nodes
4454 }
4456 // ignore negative width and height values #1599
4459 }
4463 // IE uses filters for opacity
4466 // IE has trouble with opacity if it does not have layout
4467 // Force it by setting the zoom level
4470 // Set the alpha filter to set the opacity
4471 var opacity = parseInt( value, 10 ) + "" === "NaN" ? "" : "alpha(opacity=" + value * 100 + ")";
4474 }
4479 }
4481 // Make sure we're using the right name for getting the float value
4484 }
4490 }
4493 },
4504 }
4509 }
4515 }
4516 });
4517 }
4523 }
4526 }
4529 },
4534 // IE uses filters for opacity
4542 ret;
4543 }
4545 // Make sure we're using the right name for getting the float value
4548 }
4555 // Only "float" is needed here
4558 }
4566 }
4572 }
4574 // We should always get a number back from opacity
4577 }
4584 // From the awesome hack by Dean Edwards
4585 // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
4587 // If we're not dealing with a regular pixel number
4588 // but a number that has a weird ending, we need to convert it to pixels
4590 // Remember the original values
4593 // Put in the new values to get a computed value out
4598 // Revert the changed values
4601 }
4602 }
4605 },
4607 // A method for quickly swapping in/out CSS properties to get correct calculations
4611 // Remember the old values, and insert the new ones
4615 }
4619 // Revert the old values
4622 }
4623 }
4624 });
4636 };
4640 };
4641 }
4645 rinput = /color|date|datetime|email|hidden|month|number|password|range|search|tel|text|time|url|week/i,
4653 // Keep a copy of the old load
4660 // Don't do a request if no elements are being requested
4663 }
4669 }
4671 // Default to a GET request
4674 // If the second parameter was provided
4676 // If it's a function
4678 // We assume that it's the callback
4682 // Otherwise, build a param string
4686 }
4687 }
4691 // Request the remote document
4698 // If successful, inject the HTML into all the matched elements
4700 // See if a selector was specified
4702 // Create a dummy div to hold the results
4704 // inject the contents of the document in, removing the scripts
4705 // to avoid any 'Permission Denied' errors in IE
4708 // Locate the specified elements
4711 // If not, just inject the full result
4713 }
4717 }
4718 }
4719 });
4722 },
4726 },
4730 })
4735 })
4744 }) :
4747 }
4748 });
4750 // Attach a bunch of functions for handling common AJAX events
4751 jQuery.each( "ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split(" "), function( i, o ) {
4754 };
4755 });
4760 // shift arguments if data argument was omited
4765 }
4772 dataType: type
4773 });
4774 },
4778 },
4782 },
4785 // shift arguments if data argument was omited
4789 data = {};
4790 }
4797 dataType: type
4798 });
4799 },
4803 },
4805 ajaxSettings: {
4812 /*
4813 timeout: 0,
4814 data: null,
4815 username: null,
4816 password: null,
4817 traditional: false,
4818 */
4819 // Create the request object; Microsoft failed to properly
4820 // implement the XMLHttpRequest in IE7 (can't request local files),
4821 // so we use the ActiveXObject when it is available
4822 // This function can be overriden by calling jQuery.ajaxSetup
4823 xhr: window.XMLHttpRequest && (window.location.protocol !== "file:" || !window.ActiveXObject) ?
4826 } :
4831 },
4832 accepts: {
4839 }
4840 },
4842 // Last-Modified header cache for next request
4843 lastModified: {},
4844 etag: {},
4853 // convert data if not already a string
4856 }
4858 // Handle JSONP Parameter Callbacks
4863 }
4866 }
4868 }
4870 // Build temporary JSONP function
4874 // Replace the =? sequence both in the query string and the data
4877 }
4881 // We need to make sure
4882 // that a JSONP style response is executed properly
4885 // Handle JSONP-style loading
4890 // Garbage collect
4899 }
4900 };
4901 }
4905 }
4910 // try replacing _= if it is there
4913 // if nothing was replaced, add timestamp to the end
4915 }
4917 // If data is available, append data to url for get requests
4920 }
4922 // Watch for a new set of requests
4925 }
4927 // Matches an absolute URL, and saves the domain
4931 // If we're requesting a remote document
4932 // and trying to load JSON or Script with a GET
4939 }
4941 // Handle Script loading
4945 // Attach handlers for all browsers
4953 // Handle memory leak in IE
4957 }
4958 }
4959 };
4960 }
4962 // Use insertBefore instead of appendChild to circumvent an IE6 bug.
4963 // This arises when a base node is used (#2709 and #4378).
4966 // We handle everything using the script element injection
4968 }
4972 // Create the request object
4977 }
4979 // Open the socket
4980 // Passing null username, generates a login popup on Opera (#2865)
4985 }
4987 // Need an extra try/catch for cross domain requests in Firefox 3
4989 // Set the correct header, if data is being sent
4992 }
4994 // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
4998 }
5002 }
5003 }
5005 // Set header so the called script knows that it's an XMLHttpRequest
5006 // Only send the header if it's not a remote XHR
5009 }
5011 // Set the Accepts header for the server, depending on the dataType
5017 // Allow custom headers/mimetypes and early abort
5019 // Handle the global AJAX counter
5022 }
5024 // close opended socket
5027 }
5031 }
5033 // Wait for a response to come back
5035 // The request was aborted
5037 // Opera doesn't call onreadystatechange before this point
5038 // so we simulate the call
5041 }
5046 }
5048 // The transfer is complete and the data is available, or the request timed out
5064 // Watch for, and catch, XML document parse errors
5066 // process the data (runs the xml through httpData regardless of callback)
5071 }
5072 }
5074 // Make sure that the request was successful or notmodified
5076 // JSONP handles its own success callback
5079 }
5082 }
5084 // Fire the complete handlers
5089 }
5091 // Stop memory leaks
5094 }
5095 }
5096 };
5098 // Override the abort handler, if we can (IE doesn't allow it, but that's OK)
5099 // Opera doesn't fire onreadystatechange at all on abort
5105 }
5108 };
5111 // Timeout checker
5114 // Check to see if the request is still happening
5117 }
5119 }
5121 // Send the data
5126 // Fire the complete handlers
5128 }
5130 // firefox 1.5 doesn't fire statechange for sync requests
5133 }
5136 // If a local callback was specified, fire it and pass it the data
5139 }
5141 // Fire the global callback
5144 }
5145 }
5148 // Process result
5151 }
5153 // The request was completed
5156 }
5158 // Handle the global AJAX counter
5161 }
5162 }
5166 }
5168 // return XMLHttpRequest to allow aborting the request etc.
5170 },
5173 // If a local callback was specified, fire it
5176 }
5178 // Fire the global callback
5181 }
5182 },
5184 // Counter for holding the number of active queries
5187 // Determines if an XMLHttpRequest was successful or not
5190 // IE error sometimes returns 1223 when it should be 204 so treat it as success, see #1450
5192 // Opera returns 0 when status is 304
5198 },
5200 // Determines if an XMLHttpRequest returns NotModified
5207 }
5211 }
5213 // Opera returns 0 when status is 304
5215 },
5224 }
5226 // Allow a pre-filtering function to sanitize the response
5227 // s is checked to keep backwards compatibility
5230 }
5232 // The filter can actually parse the response
5234 // Get the JavaScript object, if JSON is used.
5238 // If the type is "script", eval it in global context
5241 }
5242 }
5245 },
5247 // Serialize an array of form elements or a set of
5248 // key/values into a query string
5252 // Set traditional to true for jQuery <= 1.3.2 behavior.
5255 }
5257 // If an array was passed in, assume that it is an array of form elements.
5259 // Serialize the form elements
5262 });
5265 // If traditional, encode the "old" way (the way 1.3.2 or older
5266 // did it), otherwise encode params recursively.
5269 }
5270 }
5272 // Return the resulting serialization
5277 // Serialize array item.
5280 // Treat each array item as a scalar.
5283 // If array item is non-scalar (array or object), encode its
5284 // numeric index to resolve deserialization ambiguity issues.
5285 // Note that rack (as of 1.0.0) can't currently deserialize
5286 // nested arrays properly, and attempting to do so may cause
5287 // a server error. Possible fixes are to modify rack's
5288 // deserialization algorithm or to provide an option or flag
5289 // to force array serialization to be shallow.
5290 buildParams( prefix + "[" + ( typeof v === "object" || jQuery.isArray(v) ? i : "" ) + "]", v );
5291 }
5292 });
5295 // Serialize object item.
5298 });
5301 // Serialize scalar item.
5303 }
5304 }
5307 // If value is a function, invoke it and return its value
5310 }
5311 }
5312 });
5316 timerId,
5317 fxAttrs = [
5318 // height animations
5320 // width animations
5322 // opacity animations
5324 ];
5350 }
5355 }
5358 }
5359 }
5361 // Set the display of the elements in a second loop
5362 // to avoid the constant reflow
5365 }
5368 }
5369 },
5380 }
5381 }
5383 // Set the display of the elements in a second loop
5384 // to avoid the constant reflow
5387 }
5390 }
5391 },
5393 // Save the old toggle function
5406 });
5410 }
5413 },
5418 },
5425 }
5439 }
5443 }
5446 // Store display property
5449 // Make sure that nothing sneaks out
5451 }
5454 // Create (if needed) and add to specialEasing
5457 }
5458 }
5462 }
5480 // We need to compute starting value
5485 }
5487 // If a +=/-= token was provided, we're doing a relative animation
5490 }
5496 }
5497 }
5498 });
5500 // For JS strict compliance
5502 });
5503 },
5510 }
5513 // go in reverse order so anything added to the queue during the loop is ignored
5517 // force the next step to be the last
5519 }
5522 }
5523 }
5524 });
5526 // start the next in the queue if the last step wasn't forced
5529 }
5532 }
5534 });
5536 // Generate shortcuts for custom animations
5546 };
5547 });
5556 };
5561 // Queueing
5566 }
5569 }
5570 };
5573 },
5575 easing: {
5578 },
5581 }
5582 },
5584 timers: [],
5593 }
5594 }
5596 });
5599 // Simple function for setting a style value
5603 }
5607 // Set display property to block for height/width animations
5610 }
5611 },
5613 // Get the current size
5615 if ( this.elem[this.prop] != null && (!this.elem.style || this.elem.style[this.prop] == null) ) {
5617 }
5621 },
5623 // Start an animation from one number to another
5635 }
5641 }
5642 },
5644 // Simple 'show' function
5646 // Remember where we started, so that we can go back to it later
5650 // Begin the animation
5651 // Make sure that we start at a small width/height to avoid any
5652 // flash of content
5655 // Start by showing the element
5657 },
5659 // Simple 'hide' function
5661 // Remember where we started, so that we can go back to it later
5665 // Begin the animation
5667 },
5669 // Each step of an animation
5683 }
5684 }
5688 // Reset the overflow
5691 // Reset the display
5697 }
5698 }
5700 // Hide the element if the "hide" operation was done
5703 }
5705 // Reset the properties, if the item has been hidden or shown
5709 }
5710 }
5712 // Execute the complete function
5714 }
5722 // Perform the easing function, defaults to swing
5725 this.pos = jQuery.easing[specialEasing || defaultEasing](this.state, n, 0, 1, this.options.duration);
5728 // Perform the next step of the animation
5730 }
5733 }
5734 };
5743 }
5744 }
5748 }
5749 },
5754 },
5756 speeds: {
5759 // Default speed
5761 },
5763 step: {
5766 },
5770 fx.elem.style[ fx.prop ] = (fx.prop === "width" || fx.prop === "height" ? Math.max(0, fx.now) : fx.now) + fx.unit;
5773 }
5774 }
5775 }
5776 });
5783 };
5784 }
5791 });
5794 }
5802 });
5803 }
5807 }
5811 }
5813 var box = elem.getBoundingClientRect(), doc = elem.ownerDocument, body = doc.body, docElem = doc.documentElement,
5814 clientTop = docElem.clientTop || body.clientTop || 0, clientLeft = docElem.clientLeft || body.clientLeft || 0,
5815 top = box.top + (self.pageYOffset || jQuery.support.boxModel && docElem.scrollTop || body.scrollTop ) - clientTop,
5816 left = box.left + (self.pageXOffset || jQuery.support.boxModel && docElem.scrollLeft || body.scrollLeft) - clientLeft;
5819 };
5828 });
5829 }
5833 }
5837 }
5844 prevComputedStyle = defaultView ? defaultView.getComputedStyle( elem, null ) : elem.currentStyle,
5850 }
5860 if ( jQuery.offset.doesNotAddBorder && !(jQuery.offset.doesAddBorderForTableAndCells && /^t(able|d|h)$/i.test(elem.nodeName)) ) {
5863 }
5866 }
5868 if ( jQuery.offset.subtractsBorderForOverflowNotVisible && computedStyle.overflow !== "visible" ) {
5871 }
5874 }
5879 }
5884 }
5887 };
5888 }
5892 var body = document.body, container = document.createElement("div"), innerDiv, checkDiv, table, td, bodyMarginTop = parseFloat( jQuery.curCSS(body, "marginTop", true) ) || 0,
5893 html = "<div style='position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;'><div></div></div><table style='position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;' cellpadding='0' cellspacing='0'><tr><td></td></tr></table>";
5895 jQuery.extend( container.style, { position: "absolute", top: 0, left: 0, margin: 0, border: 0, width: "1px", height: "1px", visibility: "hidden" } );
5907 // safari subtracts parent border width here which is 5px
5919 },
5929 }
5932 },
5935 // set position first, in-case top/left are set even on static elem
5938 }
5946 }
5951 };
5957 }
5958 }
5959 };
5966 }
5970 // Get *real* offsetParent
5973 // Get correct offsets
5975 parentOffset = /^body|html$/i.test(offsetParent[0].nodeName) ? { top: 0, left: 0 } : offsetParent.offset();
5977 // Subtract element margins
5978 // note: when an element has margin: auto the offsetLeft and marginLeft
5979 // are the same in Safari causing offset.left to incorrectly be 0
5983 // Add offsetParent borders
5985 parentOffset.left += parseFloat( jQuery.curCSS(offsetParent[0], "borderLeftWidth", true) ) || 0;
5987 // Subtract the two offsets
5991 };
5992 },
5997 while ( offsetParent && (!/^body|html$/i.test(offsetParent.nodeName) && jQuery.css(offsetParent, "position") === "static") ) {
5999 }
6001 });
6002 }
6003 });
6006 // Create scrollLeft and scrollTop methods
6015 }
6018 // Set the scroll offset
6026 );
6030 }
6031 });
6035 // Return the scroll offset
6040 }
6041 };
6042 });
6046 elem :
6050 }
6051 // Create innerHeight, innerWidth, outerHeight and outerWidth methods
6056 // innerHeight and innerWidth
6061 };
6063 // outerHeight and outerWidth
6068 };
6071 // Get window width or height
6075 }
6081 });
6082 }
6085 // Everyone else use document.documentElement or document.body depending on Quirks vs Standards mode
6086 elem.document.compatMode === "CSS1Compat" && elem.document.documentElement[ "client" + name ] ||
6089 // Get document width or height
6091 // Either scroll[Width/Height] or offset[Width/Height], whichever is greater
6096 ) :
6098 // Get or set width or height on the element
6100 // Get width or height on the element
6103 // Set the width or height on the element (default to pixels if value is unitless)
6105 };
6107 });
6108 // Expose jQuery to the global object